home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-04 / mawk10.zip / GDECL.AWK < prev    next >
Text File  |  1991-10-05  |  3KB  |  137 lines
  1.  
  2. # parse a C declaration by recursive descent
  3. # 
  4. #  decl.awk with extra escapes \
  5.  
  6. ################################################
  7. ############################################
  8.  
  9.  
  10. #   lexical scanner -- gobble()
  11. #   input : string s -- treated as a regular expression
  12. #   gobble eats SPACE, then eats longest match of s off front
  13. #   of global variable line.
  14. #   Cuts the matched part off of line
  15. #
  16.  
  17.  
  18. function gobble(s,  x)  
  19. {
  20.   sub( /^ /, "", line)  # eat SPACE if any
  21.  
  22.   # surround s with parenthesis to make sure ^ acts on the
  23.   # whole thing
  24.  
  25.   match(line, "^" "(" s ")")
  26.   x = substr(line, 1, RLENGTH)
  27.   line = substr(line, RLENGTH+1)
  28.   return x 
  29. }
  30.  
  31.  
  32. function ptr_to(n,  x)  # print "pointer to" , n times
  33. { n = int(n)
  34.   if ( n <= 0 )  return ""
  35.   x = "pointer to" ; n--
  36.   while ( n-- )  x = x " pointer to"
  37.   return x
  38. }
  39.  
  40.  
  41. #recursively get a decl
  42. # returns an english description of the declaration or
  43. # "" if not a C declaration.
  44.  
  45. function  decl(   x, t, ptr_part)
  46. {
  47.  
  48.   x = gobble("[* ]+")   # get list of *** ...
  49.   gsub(/ /, "", x)   # remove all SPACES
  50.   ptr_part = ptr_to( length(x) )
  51.  
  52.   # We expect to see either an identifier or '('
  53.   #
  54.  
  55.   if ( gobble("\\(") )
  56.   { 
  57.     # this is the recursive descent part
  58.     # we expect to match a declaration and closing ')'
  59.     # If not return "" to indicate  failure
  60.  
  61.       if ( (x = decl()) == "" || gobble( "\\)" ) == "" ) return ""
  62.  
  63.   }
  64.   else  #  expecting an identifier
  65.   {
  66.     if ( (x = gobble(id)) == "" )  return ""
  67.     x = x ":"
  68.   }
  69.  
  70.   # finally look for ()
  71.   # or  [ opt_size ]
  72.  
  73.   while ( 1 )
  74.      if ( gobble( funct_mark ) )  x = x " function returning"
  75.      else
  76.      if ( t = gobble( array_mark ) )
  77.      { gsub(/ /, "", t)
  78.        x = x " array" t " of"
  79.      }
  80.      else  break
  81.  
  82.  
  83.    x = x " "  ptr_part
  84.    return x
  85. }
  86.     
  87.  
  88. BEGIN { id = "[_A-Za-z][_A-Za-z0-9]*" 
  89.         funct_mark = "\\([ \t]*\\)"
  90.     array_mark = "\\[[ \t]*[_A-Za-z0-9]*[ \t]*\\]"
  91.  
  92. # I've assumed types are keywords or all CAPS or end in _t
  93. # Other conventions could be added.
  94.  
  95.     type0 = "int|char|short|long|double|float|void" 
  96.     type1 = "[_A-Z][_A-Z0-9]*"  #  types are CAPS
  97.     type2 = "[_A-Za-z][_A-Za-z0-9]*_t"  # end in _t
  98.  
  99.     types = "(" type0 "|" type1 "|" type2 ")"
  100. }
  101.  
  102.  
  103. {   
  104.  
  105.     gsub( /\/\*([^*]|\*[^\/])*(\*\/|$)/ , " ") # remove comments
  106.     gsub( /[ \t]+/, " ")  # squeeze white space to a single space
  107.  
  108.  
  109.     line = $0
  110.  
  111.     scope = gobble( "extern|static" )
  112.  
  113.     if ( type = gobble("(struct|union|enum) ") )
  114.             type = type gobble(id)  #  get the tag
  115.     else
  116.     {
  117.  
  118.        type = gobble("(un)?signed ") gobble( types )
  119.  
  120.     }
  121.     
  122.     if ( ! type )  next
  123.     
  124.     if ( (x = decl()) && gobble( ";") )
  125.     {
  126.       x  =  x " " type
  127.       if ( scope )  x = x " (" scope ")"
  128.       gsub( /  +/, " ", x)  # 
  129.       print x
  130.     }
  131.  
  132. }
  133.  
  134.  
  135.  
  136.  
  137.